#include "eventloop.h"
#include <thread>
#include <memory>
#include <iostream>
#include "assert.h"
#include <sys/prctl.h>
#include "public_define.h"
using namespace std;
using namespace DcAdr;

vector<shared_ptr<EventLoop>> EventLoop::m_loops((int)ThreadType::E_ThreadCount);
std::string thread_name[] = {"dc_loop", "dc_cache", "dc_fileCache", "dc_fileupload", "dc_dense", "dc_signal", "dc_signal_2", "dc_sendsignal", "dc_vediosend", "dc_count"};

EventLoop::EventLoop() : m_isRunning(true)
{
}

EventLoop::~EventLoop()
{
}

void EventLoop::init()
{
    // 1. 遍历所有线程类型（E_ThreadCount表示线程总数，由ThreadType枚举定义）
    for (int i = 0; i < (int)ThreadType::E_ThreadCount; ++i)
    {
        // 2. 向全局线程容器g_c3bThread中添加一个新线程
        global_data::g_c3bThread.emplace_back(thread(// 3. 线程执行的Lambda函数，捕获外部变量i（按值捕获）
            [=]()  
            {
                // 4. 获取当前线程的名称（thread_name是存储线程名的数组）
                std::string name = thread_name[i];
                try
                {
                    /* code */
                    // 5. 调用prctl系统调用设置线程名称（便于调试时识别）
                    int ret = prctl(PR_SET_NAME, name.c_str());
                    (void)ret;  // 6. 忽略返回值（避免未使用变量警告）
                    
                    // 7. 创建EventLoop实例并存储到m_loops数组（智能指针管理）
                    m_loops[i] = make_shared<EventLoop>();
                    
                    // 8. 日志记录线程创建成功，包含线程名称
                    Log_Info("create thread success; thread_name:{}", name);
                    
                    // 9. 启动当前EventLoop的事件循环（进入事件处理循环）
                    m_loops[i]->exec();
                }
                // 10. 捕获并处理线程执行中的异常
                catch(const std::exception& e)
                {
                    // 11. 日志记录异常信息：异常内容、线程名、索引
                    Log_Info("gd Exception thread exception occure {}; thread_name:{}, index {} ",e.what(),name, i);
                }
                               
            }));
        
    }
}

shared_ptr<EventLoop> EventLoop::getInstance(ThreadType type)
{
    return m_loops[(int)type];
}

void EventLoop::exec()
{
    // 1. 循环条件：只要m_isRunning为true（事件循环运行标志），就持续运行
    while (m_isRunning)
    {
        try
        {
            /* code */
            // 2. 定义一个临时容器，用于存放待执行的任务（函数对象）
            vector<function<void()>> func;
            {
                // 3. 创建unique_lock加锁（自动管理锁的生命周期，离开作用域自动解锁）
                std::unique_lock<std::mutex> lock(m_mutex);
                // 4. 循环等待：如果任务队列m_queue为空，就阻塞等待
                while (m_queue.empty())
                {
                    // 5. 释放锁并等待条件变量m_cond被唤醒（被唤醒后重新获取锁）
                    m_cond.wait(lock);
                    // 注释掉的代码：带超时的等待（最多等1秒）
                    // m_cond.wait_for(lock, std::chrono::seconds(1));
                }
                // 6. 交换队列内容：将m_queue中的任务全部转移到临时容器func中
                //    目的是减少锁的持有时间（后续执行任务时无需持有锁）
                func.swap(m_queue);
            }
            // 7. 遍历临时容器中的所有任务，依次执行
            for (auto &item : func)
            {
                item();  // 8. 执行单个任务（函数对象）
            }
        }
        // 9. 捕获任务执行过程中可能抛出的异常
        catch(const std::exception& e)
        {
            // 10. 记录异常信息到日志
           Log_Info("gd Exception thread1 exception occure {};",e.what());
        }
    }
}
